home *** CD-ROM | disk | FTP | other *** search
/ Network PC / Network PC.iso / amiga utilities / communication / bbs / termv4.6 / extras / source / term-source.lha / TrapPanel.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-03-18  |  22.2 KB  |  992 lines
  1. /*
  2. **    TrapPanel.c
  3. **
  4. **    Editing panel for trap list
  5. **
  6. **    Copyright © 1990-1996 by Olaf `Olsen' Barthel
  7. **        All Rights Reserved
  8. */
  9.  
  10. #ifndef _GLOBAL_H
  11. #include "Global.h"
  12. #endif
  13.  
  14. enum    {    GAD_LIST,GAD_SEQUENCE,GAD_COMMAND,
  15.         GAD_TOP,GAD_UP,GAD_DOWN,GAD_END,
  16.         GAD_NEW,GAD_REMOVE,GAD_CLEAR,
  17.         GAD_LOAD,GAD_SAVE,GAD_USE,GAD_CLOSE,
  18.         GAD_DISCARD
  19.     };
  20.  
  21. BOOL
  22. TrapPanelConfig(struct Configuration *LocalConfig,BOOLEAN *ChangedPtr)
  23. {
  24.     struct LayoutHandle    *Handle;
  25.     struct GenericList    *TrapList;
  26.     struct TrapNode        *Node,
  27.                 *Next;
  28.     BOOL             Changed;
  29.  
  30.     Changed = FALSE;
  31.  
  32.     ObtainSemaphore(&GenericListTable[GLIST_TRAP] -> ListSemaphore);
  33.  
  34.     TrapList = GenericListTable[GLIST_TRAP];
  35.  
  36.     if(Handle = LT_CreateHandleTags(Window -> WScreen,
  37.         LH_LocaleHook,    &LocaleHook,
  38.     TAG_DONE))
  39.     {
  40.         struct Window    *LocalWindow;
  41.         struct IBox     Bounds;
  42.  
  43.         LT_New(Handle,
  44.             LA_Type,    VERTICAL_KIND,
  45.         TAG_DONE);
  46.         {
  47.             LT_New(Handle,
  48.                 LA_Type,    VERTICAL_KIND,
  49.                 LA_LabelID,    MSG_TRAPPANEL_TRAP_CONTROLS_TXT,
  50.             TAG_DONE);
  51.             {
  52.                 LONG MaxWidth,MaxHeight;
  53.  
  54.                 MaxWidth = MaxHeight = 0;
  55.  
  56.                 if(TrapList)
  57.                 {
  58.                     struct Node *Node;
  59.                     LONG Len;
  60.  
  61.                     for(Node = (struct Node *)TrapList -> ListHeader . mlh_Head ; Node -> ln_Succ ; Node = Node -> ln_Succ)
  62.                     {
  63.                         Len = strlen(Node -> ln_Name);
  64.  
  65.                         if(Len > MaxWidth)
  66.                             MaxWidth = Len;
  67.  
  68.                         MaxHeight++;
  69.                     }
  70.                 }
  71.  
  72.                 if(MaxWidth < 30)
  73.                     MaxWidth = 30;
  74.  
  75.                 if(MaxHeight < 10)
  76.                     MaxHeight = 10;
  77.                 else
  78.                 {
  79.                     if(MaxHeight > 20)
  80.                         MaxHeight = 20;
  81.                 }
  82.  
  83.                 LT_New(Handle,
  84.                     LA_Type,    LISTVIEW_KIND,
  85.                     LA_LabelID,    MSG_TRAPPANEL_TRAP_LIST_TXT,
  86.                     LA_LabelPlace,    PLACE_LEFT,
  87.                     LA_Chars,    30,
  88.                     LA_Lines,    10,
  89.                     LA_ID,        GAD_LIST,
  90.                     LALV_CursorKey,    TRUE,
  91.                     LALV_MaxGrowX,    MaxWidth,
  92.                     LALV_MaxGrowY,    MaxHeight,
  93.                     LALV_ResizeY,    TRUE,
  94.                     LALV_ResizeX,    TRUE,
  95.                     GTLV_Labels,    TrapList,
  96.  
  97.                     Kick30 ? LALV_Link : TAG_IGNORE, NIL_LINK,
  98.                 TAG_DONE);
  99.  
  100.                 LT_New(Handle,
  101.                     LA_Type,    STRING_KIND,
  102.                     LA_LabelID,    MSG_TRAPPANEL_SEQUENCE_TXT,
  103.                     LA_ID,        GAD_SEQUENCE,
  104.                     GTST_MaxChars,    255,
  105.                     GA_Disabled,    TRUE,
  106.                 TAG_DONE);
  107.  
  108.                 LT_New(Handle,
  109.                     LA_Type,    STRING_KIND,
  110.                     LA_LabelID,    MSG_TRAPPANEL_COMMAND_TXT,
  111.                     LA_ID,        GAD_COMMAND,
  112.                     GTST_MaxChars,    255,
  113.                     GA_Disabled,    TRUE,
  114.                 TAG_DONE);
  115.  
  116.                 LT_EndGroup(Handle);
  117.             }
  118.  
  119.             LT_New(Handle,
  120.                 LA_Type,    HORIZONTAL_KIND,
  121.             TAG_DONE);
  122.             {
  123.                 LT_New(Handle,
  124.                     LA_Type,    HORIZONTAL_KIND,
  125.                     LA_LabelID,    MSG_V36_0038,
  126.                     LA_Spread,    TRUE,
  127.                     LA_SameSize,    TRUE,
  128.                 TAG_DONE);
  129.                 {
  130.                     LT_New(Handle,
  131.                         LA_Type,    TAPEDECK_KIND,
  132.                         LATD_ButtonType,TDBT_PREVIOUS,
  133.                         LATD_Smaller,    TRUE,
  134.                         LA_ID,        GAD_TOP,
  135.                         LA_NoKey,    TRUE,
  136.                         GA_Disabled,    TRUE,
  137.                     TAG_DONE);
  138.  
  139.                     LT_New(Handle,
  140.                         LA_Type,    TAPEDECK_KIND,
  141.                         LATD_ButtonType,TDBT_REWIND,
  142.                         LATD_Smaller,    TRUE,
  143.                         LA_ID,        GAD_UP,
  144.                         LA_NoKey,    TRUE,
  145.                         GA_Disabled,    TRUE,
  146.                     TAG_DONE);
  147.  
  148.                     LT_New(Handle,
  149.                         LA_Type,    TAPEDECK_KIND,
  150.                         LATD_ButtonType,TDBT_PLAY,
  151.                         LATD_Smaller,    TRUE,
  152.                         LA_ID,        GAD_DOWN,
  153.                         LA_NoKey,    TRUE,
  154.                         GA_Disabled,    TRUE,
  155.                     TAG_DONE);
  156.  
  157.                     LT_New(Handle,
  158.                         LA_Type,    TAPEDECK_KIND,
  159.                         LATD_ButtonType,TDBT_NEXT,
  160.                         LATD_Smaller,    TRUE,
  161.                         LA_ID,        GAD_END,
  162.                         LA_NoKey,    TRUE,
  163.                         GA_Disabled,    TRUE,
  164.                     TAG_DONE);
  165.  
  166.                     LT_EndGroup(Handle);
  167.                 }
  168.  
  169.                 LT_New(Handle,
  170.                     LA_Type,    HORIZONTAL_KIND,
  171.                     LA_LabelID,    MSG_V36_0043,
  172.                     LA_Spread,    TRUE,
  173.                     LA_SameSize,    TRUE,
  174.                 TAG_DONE);
  175.                 {
  176.                     LT_New(Handle,
  177.                         LA_Type,    BUTTON_KIND,
  178.                         LA_LabelID,    MSG_FASTMACROPANEL_NEW_GAD,
  179.                         LA_ID,        GAD_NEW,
  180.                     TAG_DONE);
  181.  
  182.                     LT_New(Handle,
  183.                         LA_Type,    BUTTON_KIND,
  184.                         LA_LabelID,    MSG_GLOBAL_REMOVE_GAD,
  185.                         LA_ID,        GAD_REMOVE,
  186.                         GA_Disabled,    TRUE,
  187.                     TAG_DONE);
  188.  
  189.                     LT_New(Handle,
  190.                         LA_Type,    BUTTON_KIND,
  191.                         LA_LabelID,    MSG_UPLOADQUEUE_CLEAR_TXT,
  192.                         LA_ID,        GAD_CLEAR,
  193.                         GA_Disabled,    TrapList -> ListHeader . mlh_Head -> mln_Succ == NULL,
  194.                     TAG_DONE);
  195.  
  196.                     LT_EndGroup(Handle);
  197.                 }
  198.  
  199.                 LT_EndGroup(Handle);
  200.             }
  201.  
  202.             LT_New(Handle,
  203.                 LA_Type,    VERTICAL_KIND,
  204.             TAG_DONE);
  205.             {
  206.                 LT_New(Handle,LA_Type,XBAR_KIND,LAXB_FullSize,TRUE,TAG_DONE);
  207.  
  208.                 LT_EndGroup(Handle);
  209.             }
  210.  
  211.             LT_New(Handle,LA_Type,HORIZONTAL_KIND,
  212.                 LAGR_SameSize,    TRUE,
  213.                 LAGR_Spread,    TRUE,
  214.                 LA_ExtraSpace,    TRUE,
  215.             TAG_DONE);
  216.             {
  217.                 LT_New(Handle,
  218.                     LA_Type,    BUTTON_KIND,
  219.                     LA_LabelID,    MSG_GLOBAL_USE_GAD,
  220.                     LA_ID,        GAD_USE,
  221.                     LABT_ReturnKey,    TRUE,
  222.                     LABT_ExtraFat,    TRUE,
  223.                 TAG_DONE);
  224.  
  225.                 LT_New(Handle,
  226.                     LA_Type,    BUTTON_KIND,
  227.                     LA_LabelID,    MSG_GLOBAL_LOAD_GAD,
  228.                     LA_ID,        GAD_LOAD,
  229.                 TAG_DONE);
  230.  
  231.                 LT_New(Handle,
  232.                     LA_Type,    BUTTON_KIND,
  233.                     LA_LabelID,    MSG_GLOBAL_SAVE_GAD,
  234.                     LA_ID,        GAD_SAVE,
  235.                     GA_Disabled,    TrapList -> ListHeader . mlh_Head -> mln_Succ == NULL,
  236.                 TAG_DONE);
  237.  
  238.                 LT_New(Handle,
  239.                     LA_Type,    BUTTON_KIND,
  240.                     LA_LabelID,    MSG_DISCARD_GAD,
  241.                     LA_ID,        GAD_DISCARD,
  242.                 TAG_DONE);
  243.  
  244.                 LT_New(Handle,
  245.                     LA_Type,    BUTTON_KIND,
  246.                     LA_LabelID,    MSG_GLOBAL_CLOSE_TXT,
  247.                     LA_ID,        GAD_CLOSE,
  248.                     LABT_EscKey,    TRUE,
  249.                 TAG_DONE);
  250.  
  251.                 LT_EndGroup(Handle);
  252.             }
  253.  
  254.             LT_EndGroup(Handle);
  255.         }
  256.  
  257.         if(Screen && Window)
  258.         {
  259.             Bounds . Left    = Window -> LeftEdge;
  260.             Bounds . Top    = Window -> TopEdge;
  261.             Bounds . Width    = Window -> Width;
  262.             Bounds . Height    = Window -> Height;
  263.         }
  264.  
  265.         if(LocalWindow = LT_Build(Handle,
  266.             LAWN_TitleID,        MSG_TRAPPANEL_TRAP_PREFERENCES_TXT,
  267.             LAWN_IDCMP,        IDCMP_CLOSEWINDOW,
  268.             LAWN_HelpHook,        &GuideHook,
  269.             LAWN_Parent,        Window,
  270.             WA_DepthGadget,        TRUE,
  271.             WA_CloseGadget,        TRUE,
  272.             WA_DragBar,        TRUE,
  273.             WA_RMBTrap,        TRUE,
  274.             WA_Activate,        TRUE,
  275.             WA_SimpleRefresh,    TRUE,
  276.  
  277.             Screen ? LAWN_Bounds : TAG_IGNORE, &Bounds,
  278.         TAG_DONE))
  279.         {
  280.             struct IntuiMessage    *Message;
  281.             BOOL             Done = FALSE;
  282.             ULONG             MsgClass;
  283.             UWORD             MsgCode;
  284.             struct Gadget        *MsgGadget;
  285.  
  286.             struct TrapNode        *Selected = NULL;
  287.             ULONG             Offset = 0;
  288.  
  289.             UBYTE              DummyBuffer[MAX_FILENAME_LENGTH],
  290.                         *DummyChar;
  291.             struct FileRequester    *FileRequest;
  292.  
  293.             GuideContext(CONTEXT_TRAPS);
  294.  
  295.             PushWindow(LocalWindow);
  296.  
  297.             do
  298.             {
  299.                 if(Wait(PORTMASK(LocalWindow -> UserPort) | SIG_BREAK) & SIG_BREAK)
  300.                     break;
  301.  
  302.                 while(Message = (struct IntuiMessage *)LT_GetIMsg(Handle))
  303.                 {
  304.                     MsgClass    = Message -> Class;
  305.                     MsgCode        = Message -> Code;
  306.                     MsgGadget    = (struct Gadget *)Message -> IAddress;
  307.  
  308.                     LT_ReplyIMsg(Message);
  309.  
  310.                     if(MsgClass == IDCMP_CLOSEWINDOW)
  311.                         Done = TRUE;
  312.  
  313.                     if(MsgClass == IDCMP_GADGETUP)
  314.                     {
  315.                         switch(MsgGadget -> GadgetID)
  316.                         {
  317.                             case GAD_CLOSE:
  318.                             case GAD_USE:
  319.  
  320.                                 if(Selected)
  321.                                 {
  322.                                     strcpy(Selected->Command,LT_GetString(Handle,GAD_COMMAND));
  323.                                     strcpy(Selected->Node.ln_Name,LT_GetString(Handle,GAD_SEQUENCE));
  324.                                 }
  325.  
  326.                                 Done = TRUE;
  327.                                 break;
  328.  
  329.                             case GAD_TOP:
  330.  
  331.                                 LT_SetAttributes(Handle,GAD_LIST,
  332.                                     GTLV_Labels,    ~0,
  333.                                 TAG_DONE);
  334.  
  335.                                 Remove((struct Node *)Selected);
  336.  
  337.                                 AddHead((struct List *)TrapList,(struct Node *)Selected);
  338.  
  339.                                 Offset = 0;
  340.  
  341.                                 LT_SetAttributes(Handle,GAD_LIST,
  342.                                     GTLV_Labels,    TrapList,
  343.                                     GTLV_Selected,    Offset,
  344.                                     GTLV_Top,    Offset,
  345.                                 TAG_DONE);
  346.  
  347.                                 LT_SetAttributes(Handle,GAD_TOP,
  348.                                     GA_Disabled,    TRUE,
  349.                                 TAG_DONE);
  350.  
  351.                                 LT_SetAttributes(Handle,GAD_UP,
  352.                                     GA_Disabled,    TRUE,
  353.                                 TAG_DONE);
  354.  
  355.                                 LT_SetAttributes(Handle,GAD_DOWN,
  356.                                     GA_Disabled,    !Selected -> Node . ln_Succ -> ln_Succ,
  357.                                 TAG_DONE);
  358.  
  359.                                 LT_SetAttributes(Handle,GAD_END,
  360.                                     GA_Disabled,    !Selected -> Node . ln_Succ -> ln_Succ,
  361.                                 TAG_DONE);
  362.  
  363.                                 Changed = TRUE;
  364.  
  365.                                 if(ChangedPtr)
  366.                                     *ChangedPtr = TRUE;
  367.  
  368.                                 break;
  369.  
  370.                             case GAD_UP:
  371.  
  372.                                 LT_SetAttributes(Handle,GAD_LIST,
  373.                                     GTLV_Labels,    ~0,
  374.                                 TAG_DONE);
  375.  
  376.                                 Node = (struct TrapNode *)Selected -> Node . ln_Pred -> ln_Pred;
  377.  
  378.                                 Remove((struct Node *)Selected);
  379.  
  380.                                 Insert((struct List *)TrapList,(struct Node *)Selected,(struct Node *)Node);
  381.  
  382.                                 Offset--;
  383.  
  384.                                 LT_SetAttributes(Handle,GAD_LIST,
  385.                                     GTLV_Labels,    TrapList,
  386.                                     GTLV_Selected,    Offset,
  387.                                     GTLV_Top,    Offset,
  388.                                 TAG_DONE);
  389.  
  390.                                 LT_SetAttributes(Handle,GAD_TOP,
  391.                                     GA_Disabled,    !Selected -> Node . ln_Pred -> ln_Pred,
  392.                                 TAG_DONE);
  393.  
  394.                                 LT_SetAttributes(Handle,GAD_UP,
  395.                                     GA_Disabled,    !Selected -> Node . ln_Pred -> ln_Pred,
  396.                                 TAG_DONE);
  397.  
  398.                                 LT_SetAttributes(Handle,GAD_DOWN,
  399.                                     GA_Disabled,    !Selected -> Node . ln_Succ -> ln_Succ,
  400.                                 TAG_DONE);
  401.  
  402.                                 LT_SetAttributes(Handle,GAD_END,
  403.                                     GA_Disabled,    !Selected -> Node . ln_Succ -> ln_Succ,
  404.                                 TAG_DONE);
  405.  
  406.                                 Changed = TRUE;
  407.  
  408.                                 if(ChangedPtr)
  409.                                     *ChangedPtr = TRUE;
  410.  
  411.                                 break;
  412.  
  413.                             case GAD_DOWN:
  414.  
  415.                                 LT_SetAttributes(Handle,GAD_LIST,
  416.                                     GTLV_Labels,    ~0,
  417.                                 TAG_DONE);
  418.  
  419.                                 Node = (struct TrapNode *)Selected -> Node . ln_Succ;
  420.  
  421.                                 Remove((struct Node *)Selected);
  422.  
  423.                                 Insert((struct List *)TrapList,(struct Node *)Selected,(struct Node *)Node);
  424.  
  425.                                 Offset++;
  426.  
  427.                                 LT_SetAttributes(Handle,GAD_LIST,
  428.                                     GTLV_Labels,    TrapList,
  429.                                     GTLV_Selected,    Offset,
  430.                                     GTLV_Top,    Offset,
  431.                                 TAG_DONE);
  432.  
  433.                                 LT_SetAttributes(Handle,GAD_TOP,
  434.                                     GA_Disabled,    !Selected -> Node . ln_Pred -> ln_Pred,
  435.                                 TAG_DONE);
  436.  
  437.                                 LT_SetAttributes(Handle,GAD_UP,
  438.                                     GA_Disabled,    !Selected -> Node . ln_Pred -> ln_Pred,
  439.                                 TAG_DONE);
  440.  
  441.                                 LT_SetAttributes(Handle,GAD_DOWN,
  442.                                     GA_Disabled,    !Selected -> Node . ln_Succ -> ln_Succ,
  443.                                 TAG_DONE);
  444.  
  445.                                 LT_SetAttributes(Handle,GAD_END,
  446.                                     GA_Disabled,    !Selected -> Node . ln_Succ -> ln_Succ,
  447.                                 TAG_DONE);
  448.  
  449.                                 Changed = TRUE;
  450.  
  451.                                 if(ChangedPtr)
  452.                                     *ChangedPtr = TRUE;
  453.  
  454.                                 break;
  455.  
  456.                             case GAD_END:
  457.  
  458.                                 LT_SetAttributes(Handle,GAD_LIST,
  459.                                     GTLV_Labels,    ~0,
  460.                                 TAG_DONE);
  461.  
  462.                                 Remove((struct Node *)Selected);
  463.  
  464.                                 AddTail((struct List *)TrapList,(struct Node *)Selected);
  465.  
  466.                                 Offset = TrapList -> ListCount - 1;
  467.  
  468.                                 LT_SetAttributes(Handle,GAD_LIST,
  469.                                     GTLV_Labels,    TrapList,
  470.                                     GTLV_Selected,    Offset,
  471.                                     GTLV_Top,    Offset,
  472.                                 TAG_DONE);
  473.  
  474.                                 LT_SetAttributes(Handle,GAD_TOP,
  475.                                     GA_Disabled,    !Selected -> Node . ln_Pred -> ln_Pred,
  476.                                 TAG_DONE);
  477.  
  478.                                 LT_SetAttributes(Handle,GAD_UP,
  479.                                     GA_Disabled,    !Selected -> Node . ln_Pred -> ln_Pred,
  480.                                 TAG_DONE);
  481.  
  482.                                 LT_SetAttributes(Handle,GAD_DOWN,
  483.                                     GA_Disabled,    !Selected -> Node . ln_Succ -> ln_Succ,
  484.                                 TAG_DONE);
  485.  
  486.                                 LT_SetAttributes(Handle,GAD_END,
  487.                                     GA_Disabled,    !Selected -> Node . ln_Succ -> ln_Succ,
  488.                                 TAG_DONE);
  489.  
  490.                                 Changed = TRUE;
  491.  
  492.                                 if(ChangedPtr)
  493.                                     *ChangedPtr = TRUE;
  494.  
  495.                                 break;
  496.  
  497.                             case GAD_NEW:
  498.  
  499.                                 if(Node = CreateTrapNode("",""))
  500.                                 {
  501.                                     LT_SetAttributes(Handle,GAD_LIST,
  502.                                         GTLV_Labels,    ~0,
  503.                                     TAG_DONE);
  504.  
  505.                                     AddTail((struct List *)TrapList,(struct Node *)Node);
  506.  
  507.                                     LT_SetAttributes(Handle,GAD_LIST,
  508.                                         GTLV_Labels,    TrapList,
  509.                                         GTLV_Selected,    TrapList -> ListCount++,
  510.                                     TAG_DONE);
  511.  
  512.                                     LT_SetAttributes(Handle,GAD_COMMAND,
  513.                                         GTST_String,    "",
  514.                                         GA_Disabled,    FALSE,
  515.                                     TAG_DONE);
  516.  
  517.                                     LT_SetAttributes(Handle,GAD_SEQUENCE,
  518.                                         GTST_String,    "",
  519.                                         GA_Disabled,    FALSE,
  520.                                     TAG_DONE);
  521.  
  522.                                     LT_SetAttributes(Handle,GAD_REMOVE,
  523.                                         GA_Disabled,    FALSE,
  524.                                     TAG_DONE);
  525.  
  526.                                     LT_SetAttributes(Handle,GAD_SAVE,
  527.                                         GA_Disabled,    FALSE,
  528.                                     TAG_DONE);
  529.  
  530.                                     LT_SetAttributes(Handle,GAD_CLEAR,
  531.                                         GA_Disabled,    FALSE,
  532.                                     TAG_DONE);
  533.  
  534.                                     Selected = Node;
  535.  
  536.                                     Offset = MsgCode;
  537.  
  538.                                     LT_SetAttributes(Handle,GAD_TOP,
  539.                                         GA_Disabled,    !Selected -> Node . ln_Pred -> ln_Pred,
  540.                                     TAG_DONE);
  541.  
  542.                                     LT_SetAttributes(Handle,GAD_UP,
  543.                                         GA_Disabled,    !Selected -> Node . ln_Pred -> ln_Pred,
  544.                                     TAG_DONE);
  545.  
  546.                                     LT_SetAttributes(Handle,GAD_DOWN,
  547.                                         GA_Disabled,    !Selected -> Node . ln_Succ -> ln_Succ,
  548.                                     TAG_DONE);
  549.  
  550.                                     LT_SetAttributes(Handle,GAD_END,
  551.                                         GA_Disabled,    !Selected -> Node . ln_Succ -> ln_Succ,
  552.                                     TAG_DONE);
  553.  
  554.                                     LT_Activate(Handle,GAD_SEQUENCE);
  555.  
  556.                                     Changed = TRUE;
  557.  
  558.                                     if(ChangedPtr)
  559.                                         *ChangedPtr = TRUE;
  560.                                 }
  561.                                 else
  562.                                     DisplayBeep(LocalWindow -> WScreen);
  563.  
  564.                                 break;
  565.  
  566.                             case GAD_CLEAR:
  567.  
  568.                                 LT_SetAttributes(Handle,GAD_LIST,
  569.                                     GTLV_Labels,    ~0,
  570.                                 TAG_DONE);
  571.  
  572.                                 FreeList((struct List *)TrapList);
  573.  
  574.                                 TrapList -> ListCount = 0;
  575.  
  576.                                 LT_SetAttributes(Handle,GAD_LIST,
  577.                                     GTLV_Labels,    TrapList,
  578.                                     GTLV_Selected,    ~0,
  579.                                 TAG_DONE);
  580.  
  581.                                 Selected = NULL;
  582.  
  583.                                 LT_SetAttributes(Handle,GAD_TOP,
  584.                                     GA_Disabled,    TRUE,
  585.                                 TAG_DONE);
  586.  
  587.                                 LT_SetAttributes(Handle,GAD_UP,
  588.                                     GA_Disabled,    TRUE,
  589.                                 TAG_DONE);
  590.  
  591.                                 LT_SetAttributes(Handle,GAD_DOWN,
  592.                                     GA_Disabled,    TRUE,
  593.                                 TAG_DONE);
  594.  
  595.                                 LT_SetAttributes(Handle,GAD_END,
  596.                                     GA_Disabled,    TRUE,
  597.                                 TAG_DONE);
  598.  
  599.                                 LT_SetAttributes(Handle,GAD_REMOVE,
  600.                                     GA_Disabled,    TRUE,
  601.                                 TAG_DONE);
  602.  
  603.                                 LT_SetAttributes(Handle,GAD_SEQUENCE,
  604.                                     GTST_String,    "",
  605.                                     GA_Disabled,    TRUE,
  606.                                 TAG_DONE);
  607.  
  608.                                 LT_SetAttributes(Handle,GAD_COMMAND,
  609.                                     GTST_String,    "",
  610.                                     GA_Disabled,    TRUE,
  611.                                 TAG_DONE);
  612.  
  613.                                 LT_SetAttributes(Handle,GAD_SAVE,
  614.                                     GA_Disabled,    TRUE,
  615.                                 TAG_DONE);
  616.  
  617.                                 LT_SetAttributes(Handle,GAD_CLEAR,
  618.                                     GA_Disabled,    TRUE,
  619.                                 TAG_DONE);
  620.  
  621.                                 Changed = TRUE;
  622.  
  623.                                 if(ChangedPtr)
  624.                                     *ChangedPtr = FALSE;
  625.  
  626.                                 break;
  627.  
  628.                             case GAD_REMOVE:
  629.  
  630.                                 if(Selected)
  631.                                 {
  632.                                     LT_SetAttributes(Handle,GAD_LIST,
  633.                                         GTLV_Labels,    ~0,
  634.                                     TAG_DONE);
  635.  
  636.                                     if(--TrapList -> ListCount)
  637.                                     {
  638.                                         if(Selected -> Node . ln_Succ -> ln_Succ)
  639.                                             Node = (struct TrapNode *)Selected -> Node . ln_Succ;
  640.                                         else
  641.                                         {
  642.                                             Node = (struct TrapNode *)Selected -> Node . ln_Pred;
  643.  
  644.                                             Offset = 0;
  645.                                         }
  646.                                     }
  647.  
  648.                                     FreeNode((struct Node *)Selected);
  649.  
  650.                                     LT_SetAttributes(Handle,GAD_LIST,
  651.                                         GTLV_Labels,    TrapList,
  652.                                         GTLV_Selected,    TrapList -> ListCount > 0 ? GetNodeOffset((struct Node *)Node,(struct List *)TrapList) : ~0,
  653.                                     TAG_DONE);
  654.  
  655.                                     if(!TrapList -> ListCount)
  656.                                     {
  657.                                         Selected = NULL;
  658.  
  659.                                         LT_SetAttributes(Handle,GAD_TOP,
  660.                                             GA_Disabled,    TRUE,
  661.                                         TAG_DONE);
  662.  
  663.                                         LT_SetAttributes(Handle,GAD_UP,
  664.                                             GA_Disabled,    TRUE,
  665.                                         TAG_DONE);
  666.  
  667.                                         LT_SetAttributes(Handle,GAD_DOWN,
  668.                                             GA_Disabled,    TRUE,
  669.                                         TAG_DONE);
  670.  
  671.                                         LT_SetAttributes(Handle,GAD_END,
  672.                                             GA_Disabled,    TRUE,
  673.                                         TAG_DONE);
  674.  
  675.                                         LT_SetAttributes(Handle,GAD_REMOVE,
  676.                                             GA_Disabled,    TRUE,
  677.                                         TAG_DONE);
  678.  
  679.                                         LT_SetAttributes(Handle,GAD_SEQUENCE,
  680.                                             GTST_String,    "",
  681.                                             GA_Disabled,    TRUE,
  682.                                         TAG_DONE);
  683.  
  684.                                         LT_SetAttributes(Handle,GAD_COMMAND,
  685.                                             GTST_String,    "",
  686.                                             GA_Disabled,    TRUE,
  687.                                         TAG_DONE);
  688.  
  689.                                         LT_SetAttributes(Handle,GAD_SAVE,
  690.                                             GA_Disabled,    TRUE,
  691.                                         TAG_DONE);
  692.  
  693.                                         LT_SetAttributes(Handle,GAD_CLEAR,
  694.                                             GA_Disabled,    TRUE,
  695.                                         TAG_DONE);
  696.                                     }
  697.                                     else
  698.                                     {
  699.                                         Selected = Node;
  700.  
  701.                                         LT_SetAttributes(Handle,GAD_COMMAND,
  702.                                             GTST_String,    Selected -> Command,
  703.                                         TAG_DONE);
  704.  
  705.                                         LT_SetAttributes(Handle,GAD_SEQUENCE,
  706.                                             GTST_String,    Selected -> Node . ln_Name,
  707.                                         TAG_DONE);
  708.  
  709.                                         LT_SetAttributes(Handle,GAD_TOP,
  710.                                             GA_Disabled,    !Selected -> Node . ln_Pred -> ln_Pred,
  711.                                         TAG_DONE);
  712.  
  713.                                         LT_SetAttributes(Handle,GAD_UP,
  714.                                             GA_Disabled,    !Selected -> Node . ln_Pred -> ln_Pred,
  715.                                         TAG_DONE);
  716.  
  717.                                         LT_SetAttributes(Handle,GAD_DOWN,
  718.                                             GA_Disabled,    !Selected -> Node . ln_Succ -> ln_Succ,
  719.                                         TAG_DONE);
  720.  
  721.                                         LT_SetAttributes(Handle,GAD_END,
  722.                                             GA_Disabled,    !Selected -> Node . ln_Succ -> ln_Succ,
  723.                                         TAG_DONE);
  724.                                     }
  725.  
  726.                                     Changed = TRUE;
  727.  
  728.                                     if(ChangedPtr)
  729.                                         *ChangedPtr = TRUE;
  730.                                 }
  731.  
  732.                                 break;
  733.  
  734.                             case GAD_LIST:
  735.  
  736.                                 if(Selected)
  737.                                 {
  738.                                     strcpy(Selected->Command,LT_GetString(Handle,GAD_COMMAND));
  739.                                     strcpy(Selected->Node.ln_Name,LT_GetString(Handle,GAD_SEQUENCE));
  740.                                 }
  741.  
  742.                                 if(Selected = (struct TrapNode *)GetListNode(MsgCode,(struct List *)TrapList))
  743.                                 {
  744.                                     Offset = MsgCode;
  745.  
  746.                                     LT_SetAttributes(Handle,GAD_SEQUENCE,
  747.                                         GTST_String,    Selected -> Node . ln_Name,
  748.                                         GA_Disabled,    FALSE,
  749.                                     TAG_DONE);
  750.  
  751.                                     LT_SetAttributes(Handle,GAD_COMMAND,
  752.                                         GTST_String,    Selected -> Command,
  753.                                         GA_Disabled,    FALSE,
  754.                                     TAG_DONE);
  755.  
  756.                                     LT_SetAttributes(Handle,GAD_REMOVE,
  757.                                         GA_Disabled,    FALSE,
  758.                                     TAG_DONE);
  759.  
  760.                                     LT_SetAttributes(Handle,GAD_TOP,
  761.                                         GA_Disabled,    !Selected -> Node . ln_Pred -> ln_Pred,
  762.                                     TAG_DONE);
  763.  
  764.                                     LT_SetAttributes(Handle,GAD_UP,
  765.                                         GA_Disabled,    !Selected -> Node . ln_Pred -> ln_Pred,
  766.                                     TAG_DONE);
  767.  
  768.                                     LT_SetAttributes(Handle,GAD_DOWN,
  769.                                         GA_Disabled,    !Selected -> Node . ln_Succ -> ln_Succ,
  770.                                     TAG_DONE);
  771.  
  772.                                     LT_SetAttributes(Handle,GAD_END,
  773.                                         GA_Disabled,    !Selected -> Node . ln_Succ -> ln_Succ,
  774.                                     TAG_DONE);
  775.                                 }
  776.  
  777.                                 break;
  778.  
  779.                             case GAD_SEQUENCE:
  780.  
  781.                                 if(Selected)
  782.                                 {
  783.                                     LT_SetAttributes(Handle,GAD_LIST,
  784.                                         GTLV_Labels,    ~0,
  785.                                     TAG_DONE);
  786.  
  787.                                     Selected = ChangeTrapNode(TrapList,Selected,(STRPTR)LT_GetAttributes(Handle,GAD_SEQUENCE,TAG_DONE),NULL);
  788.  
  789.                                     LT_SetAttributes(Handle,GAD_LIST,
  790.                                         GTLV_Labels,    TrapList,
  791.                                         GTLV_Selected,    GetNodeOffset((struct Node *)Selected,(struct List *)TrapList),
  792.                                     TAG_DONE);
  793.  
  794.                                     LT_SetAttributes(Handle,GAD_COMMAND,
  795.                                         GTST_String,    Selected -> Command,
  796.                                     TAG_DONE);
  797.  
  798.                                     LT_SetAttributes(Handle,GAD_SEQUENCE,
  799.                                         GTST_String,    Selected -> Node . ln_Name,
  800.                                     TAG_DONE);
  801.  
  802.                                     Changed = TRUE;
  803.  
  804.                                     if(ChangedPtr)
  805.                                         *ChangedPtr = TRUE;
  806.  
  807.                                     LT_Activate(Handle,GAD_COMMAND);
  808.                                 }
  809.  
  810.                                 break;
  811.  
  812.                             case GAD_COMMAND:
  813.  
  814.                                 if(Selected)
  815.                                 {
  816.                                     Selected = ChangeTrapNode(TrapList,Selected,NULL,(STRPTR)LT_GetAttributes(Handle,GAD_COMMAND,TAG_DONE));
  817.  
  818.                                     TrapsChanged = TRUE;
  819.  
  820.                                     if(ChangedPtr)
  821.                                         *ChangedPtr = TRUE;
  822.                                 }
  823.  
  824.                                 break;
  825.  
  826.                             case GAD_LOAD:
  827.  
  828.                                 SplitFileName(LastTraps,&DummyChar,DummyBuffer);
  829.  
  830.                                 LT_LockWindow(LocalWindow);
  831.  
  832.                                 if(FileRequest = GetFile(LocalWindow,LocaleString(MSG_TRAPPANEL_LOAD_TRAP_SETTINGS_TXT),DummyBuffer,FilePart(LastTraps),DummyBuffer,"#?.prefs",FALSE,FALSE,FALSE,LocaleString(MSG_GLOBAL_LOAD_TXT),TRUE))
  833.                                 {
  834.                                     LT_SetAttributes(Handle,GAD_LIST,
  835.                                         GTLV_Labels,    ~0,
  836.                                     TAG_DONE);
  837.  
  838.                                     Selected = NULL;
  839.  
  840.                                     if(!LoadTraps(DummyBuffer,TrapList))
  841.                                         ShowError(LocalWindow,ERR_LOAD_ERROR,IoErr(),DummyBuffer);
  842.                                     else
  843.                                     {
  844.                                         strcpy(LastTraps,DummyBuffer);
  845.  
  846.                                         if(LocalConfig)
  847.                                             strcpy(LocalConfig->TrapFileName,LastTraps);
  848.  
  849.                                         Changed = TRUE;
  850.  
  851.                                         if(ChangedPtr)
  852.                                             *ChangedPtr = FALSE;
  853.                                     }
  854.  
  855.                                     LT_SetAttributes(Handle,GAD_LIST,
  856.                                         GTLV_Labels,    TrapList,
  857.                                         GTLV_Selected,    ~0,
  858.                                     TAG_DONE);
  859.  
  860.                                     LT_SetAttributes(Handle,GAD_COMMAND,
  861.                                         GTST_String,    "",
  862.                                         GA_Disabled,    TRUE,
  863.                                     TAG_DONE);
  864.  
  865.                                     LT_SetAttributes(Handle,GAD_SEQUENCE,
  866.                                         GTST_String,    "",
  867.                                         GA_Disabled,    TRUE,
  868.                                     TAG_DONE);
  869.  
  870.                                     LT_SetAttributes(Handle,GAD_REMOVE,
  871.                                         GA_Disabled,    TRUE,
  872.                                     TAG_DONE);
  873.  
  874.                                     LT_SetAttributes(Handle,GAD_TOP,
  875.                                         GA_Disabled,    TRUE,
  876.                                     TAG_DONE);
  877.  
  878.                                     LT_SetAttributes(Handle,GAD_UP,
  879.                                         GA_Disabled,    TRUE,
  880.                                     TAG_DONE);
  881.  
  882.                                     LT_SetAttributes(Handle,GAD_DOWN,
  883.                                         GA_Disabled,    TRUE,
  884.                                     TAG_DONE);
  885.  
  886.                                     LT_SetAttributes(Handle,GAD_END,
  887.                                         GA_Disabled,    TRUE,
  888.                                     TAG_DONE);
  889.  
  890.                                     LT_SetAttributes(Handle,GAD_SAVE,
  891.                                         GA_Disabled,    !TrapList -> ListCount,
  892.                                     TAG_DONE);
  893.  
  894.                                     LT_SetAttributes(Handle,GAD_CLEAR,
  895.                                         GA_Disabled,    !TrapList -> ListCount,
  896.                                     TAG_DONE);
  897.  
  898.                                     FreeAslRequest(FileRequest);
  899.                                 }
  900.  
  901.                                 LT_UnlockWindow(LocalWindow);
  902.  
  903.                                 break;
  904.  
  905.                             case GAD_SAVE:
  906.  
  907.                                 if(Selected)
  908.                                 {
  909.                                     strcpy(Selected->Command,LT_GetString(Handle,GAD_COMMAND));
  910.                                     strcpy(Selected->Node.ln_Name,LT_GetString(Handle,GAD_SEQUENCE));
  911.                                 }
  912.  
  913.                                 SplitFileName(LastTraps,&DummyChar,DummyBuffer);
  914.  
  915.                                 LT_LockWindow(LocalWindow);
  916.  
  917.                                 if(FileRequest = GetFile(LocalWindow,LocaleString(MSG_TRAPPANEL_SAVE_TRAP_SETTINGS_TXT),DummyBuffer,FilePart(LastTraps),DummyBuffer,"#?.prefs",TRUE,FALSE,FALSE,LocaleString(MSG_GLOBAL_SAVE_TXT),TRUE))
  918.                                 {
  919.                                     if(!SaveTraps(DummyBuffer,(struct List *)TrapList))
  920.                                         ShowError(LocalWindow,ERR_SAVE_ERROR,IoErr(),DummyBuffer);
  921.                                     else
  922.                                     {
  923.                                         strcpy(LastTraps,DummyBuffer);
  924.  
  925.                                         if(LocalConfig)
  926.                                             strcpy(LocalConfig->TrapFileName,LastTraps);
  927.  
  928.                                         Changed = TRUE;
  929.  
  930.                                         if(ChangedPtr)
  931.                                             *ChangedPtr = FALSE;
  932.                                     }
  933.  
  934.                                     FreeAslRequest(FileRequest);
  935.                                 }
  936.  
  937.                                 LT_UnlockWindow(LocalWindow);
  938.  
  939.                                 break;
  940.  
  941.                             case GAD_DISCARD:
  942.  
  943.                                 LT_SetAttributes(Handle,GAD_LIST,
  944.                                     GTLV_Labels,    ~0,
  945.                                 TAG_DONE);
  946.  
  947.                                 FreeList((struct List *)TrapList);
  948.  
  949.                                 TrapList -> ListCount = 0;
  950.  
  951.                                 Done = Changed = TRUE;
  952.  
  953.                                 if(ChangedPtr)
  954.                                     *ChangedPtr = FALSE;
  955.  
  956.                                 LastTraps[0] = 0;
  957.  
  958.                                 if(LocalConfig)
  959.                                     strcpy(LocalConfig->TrapFileName,LastTraps);
  960.  
  961.                                 WatchTraps = FALSE;
  962.  
  963.                                 break;
  964.                         }
  965.                     }
  966.                 }
  967.             }
  968.             while(!Done);
  969.  
  970.             PopWindow();
  971.         }
  972.  
  973.         LT_DeleteHandle(Handle);
  974.     }
  975.  
  976.     for(Node = (struct TrapNode *)TrapList -> ListHeader . mlh_Head ; Next = (struct TrapNode *)Node -> Node . ln_Succ ; Node = Next)
  977.     {
  978.         if(!Node -> Node . ln_Name[0] || !Node -> SequenceLen)
  979.         {
  980.             Remove(Node);
  981.  
  982.             FreeVecPooled(Node);
  983.  
  984.             TrapList -> ListCount--;
  985.         }
  986.     }
  987.  
  988.     ReleaseSemaphore(&GenericListTable[GLIST_TRAP] -> ListSemaphore);
  989.  
  990.     return(Changed);
  991. }
  992.